

package cn.ydxiaoshaui.aip.imageclassify;

import cn.ydxiaoshaui.aip.client.BaseClient;
import cn.ydxiaoshaui.aip.error.AipError;
import cn.ydxiaoshaui.aip.http.AipRequest;
import cn.ydxiaoshaui.aip.imageclassify.bean.*;
import cn.ydxiaoshaui.aip.util.Base64Util;
import cn.ydxiaoshaui.aip.util.Util;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import java.io.IOException;
import java.util.HashMap;

public class AipImageClassify extends BaseClient {

    public AipImageClassify(String appId, String apiKey, String secretKey) {
        super(appId, apiKey, secretKey);
    }

    /**
     * 通用物体识别接口   
     * 该请求用于通用物体及场景识别，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的多个物体及场景标签。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject advancedGeneral(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.ADVANCED_GENERAL);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 通用物体识别接口
     * 该请求用于通用物体及场景识别，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的多个物体及场景标签。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return {@link AdvancedGeneral}
     */
    public AdvancedGeneral advancedGeneralPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = advancedGeneral(image, options);
        AdvancedGeneral advancedGeneral = JSON.parseObject(object.toString(),AdvancedGeneral.class);
        return advancedGeneral;
    }
    /**
     * 通用物体识别接口
     * 该请求用于通用物体及场景识别，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的多个物体及场景标签。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject advancedGeneral(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return advancedGeneral(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 通用物体识别接口
     * 该请求用于通用物体及场景识别，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的多个物体及场景标签。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return {@link AdvancedGeneral}
     */
    public AdvancedGeneral advancedGeneralPro(String image, HashMap<String, String> options) {
        JSONObject object = advancedGeneral(image, options);
        AdvancedGeneral advancedGeneral = JSON.parseObject(object.toString(),AdvancedGeneral.class);
        return advancedGeneral;
    }
    /**
     * 菜品识别接口   
     * 该请求用于菜品识别。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的菜品名称、卡路里信息、置信度。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   filter_threshold 默认0.95，可以通过该参数调节识别效果，降低非菜识别率.
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject dishDetect(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.DISH_DETECT);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 菜品识别接口
     * 该请求用于菜品识别。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的菜品名称、卡路里信息、置信度。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   filter_threshold 默认0.95，可以通过该参数调节识别效果，降低非菜识别率.
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return DishDetect
     */
    public DishDetect dishDetectPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = dishDetect(image, options);
        DishDetect dishDetect = JSON.parseObject(object.toString(),DishDetect.class);
        return dishDetect;
    }
    /**
     * 菜品识别接口
     * 该请求用于菜品识别。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的菜品名称、卡路里信息、置信度。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   filter_threshold 默认0.95，可以通过该参数调节识别效果，降低非菜识别率.
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject dishDetect(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return dishDetect(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 菜品识别接口
     * 该请求用于菜品识别。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的菜品名称、卡路里信息、置信度。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   filter_threshold 默认0.95，可以通过该参数调节识别效果，降低非菜识别率.
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return DishDetect
     */
    public DishDetect dishDetectPro(String image, HashMap<String, String> options) {
        JSONObject object = dishDetect(image, options);
        DishDetect dishDetect = JSON.parseObject(object.toString(),DishDetect.class);
        return dishDetect;
    }
    /**
     * 车型识别接口
     * 该请求用于检测一张车辆图片的具体车型。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的车辆品牌及型号。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject carDetect(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.CAR_DETECT);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 车型识别接口
     * 该请求用于检测一张车辆图片的具体车型。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的车辆品牌及型号。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public CarDetect carDetectPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = carDetect(image, options);
        CarDetect carDetect = JSON.parseObject(object.toString(),CarDetect.class);
        return carDetect;
    }

    /**
     * 车型识别接口
     * 该请求用于检测一张车辆图片的具体车型。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的车辆品牌及型号。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject carDetect(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return carDetect(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 车型识别接口
     * 该请求用于检测一张车辆图片的具体车型。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片的车辆品牌及型号。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public CarDetect carDetectPro(String image, HashMap<String, String> options) {
        JSONObject object = carDetect(image, options);
        CarDetect carDetect = JSON.parseObject(object.toString(),CarDetect.class);
        return carDetect;
    }
    /**
     * logo商标识别接口   
     * 该请求用于检测和识别图片中的品牌LOGO信息。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中LOGO的名称、位置和置信度。当效果欠佳时，可以建立子库（在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库）并通过调用logo入口接口完成自定义logo入库，提高识别效果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   custom_lib 是否只使用自定义logo库的结果，默认false：返回自定义库+默认库的识别结果
     * @return JSONObject
     */
    public JSONObject logoSearch(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.LOGO_SEARCH);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * logo商标识别接口
     * 该请求用于检测和识别图片中的品牌LOGO信息。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中LOGO的名称、位置和置信度。当效果欠佳时，可以建立子库（在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库）并通过调用logo入口接口完成自定义logo入库，提高识别效果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   custom_lib 是否只使用自定义logo库的结果，默认false：返回自定义库+默认库的识别结果
     * @return JSONObject
     */
    public LogoDetect logoSearchPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = logoSearch(image, options);
        LogoDetect logoDetect = JSON.parseObject(object.toString(),LogoDetect.class);
        return logoDetect;
    }

    /**
     * logo商标识别接口
     * 该请求用于检测和识别图片中的品牌LOGO信息。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中LOGO的名称、位置和置信度。当效果欠佳时，可以建立子库（在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库）并通过调用logo入口接口完成自定义logo入库，提高识别效果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   custom_lib 是否只使用自定义logo库的结果，默认false：返回自定义库+默认库的识别结果
     * @return JSONObject
     */
    public JSONObject logoSearch(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return logoSearch(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * logo商标识别接口
     * 该请求用于检测和识别图片中的品牌LOGO信息。即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中LOGO的名称、位置和置信度。当效果欠佳时，可以建立子库（在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库）并通过调用logo入口接口完成自定义logo入库，提高识别效果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   custom_lib 是否只使用自定义logo库的结果，默认false：返回自定义库+默认库的识别结果
     * @return JSONObject
     */
    public LogoDetect logoSearchPro(String image, HashMap<String, String> options) {
        JSONObject object = logoSearch(image, options);
        LogoDetect logoDetect = JSON.parseObject(object.toString(),LogoDetect.class);
        return logoDetect;
    }

    /**
     * logo商标识别—添加接口   
     * 使用入库接口请先在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库，建库成功后方可正常使用。
     *
     * @param image - 二进制图像数据
     * @param brief - brief，检索时带回。此处要传对应的name与code字段，name长度小于100B，code长度小于150B
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject logoAdd(byte[] image, String brief, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        
        request.addBody("brief", brief);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.LOGO_ADD);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * logo商标识别—添加接口
     * 使用入库接口请先在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库，建库成功后方可正常使用。
     *
     * @param image - 本地图片路径
     * @param brief - brief，检索时带回。此处要传对应的name与code字段，name长度小于100B，code长度小于150B
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject logoAdd(String image, String brief, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return logoAdd(data, brief, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * logo商标识别—删除接口   
     * 使用删除接口请先在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库，建库成功后先调用入库接口完成logo图片入库，删除接口用户在已入库的logo图片中删除图片。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject logoDeleteByImage(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.LOGO_DELETE);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * logo商标识别—删除接口
     * 使用删除接口请先在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库，建库成功后先调用入库接口完成logo图片入库，删除接口用户在已入库的logo图片中删除图片。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject logoDeleteByImage(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return logoDeleteByImage(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * logo商标识别—删除接口   
     * 使用删除接口请先在[控制台](https://console.bce.baidu.com/ai/#/ai/imagerecognition/overview/index)创建应用并申请建库，建库成功后先调用入库接口完成logo图片入库，删除接口用户在已入库的logo图片中删除图片。
     *
     * @param contSign - 图片签名（和image二选一，image优先级更高）
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject logoDeleteBySign(String contSign, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        request.addBody("cont_sign", contSign);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.LOGO_DELETE);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 动物识别接口
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出动物识别结果
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为6
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject animalDetect(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);

        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.ANIMAL_DETECT);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 动物识别接口
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出动物识别结果
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为6
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return AnimalDetect
     */
    public AnimalDetect animalDetectPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = animalDetect(image, options);
        AnimalDetect animalDetect = JSON.parseObject(object.toString(),AnimalDetect.class);
        return animalDetect;
    }

    /**
     * 动物识别接口
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出动物识别结果
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为6
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject animalDetect(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return animalDetect(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 动物识别接口
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出动物识别结果
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为6
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return AnimalDetect
     */
    public AnimalDetect animalDetectPro(String image, HashMap<String, String> options) {
        JSONObject object = animalDetect(image, options);
        AnimalDetect animalDetect = JSON.parseObject(object.toString(),AnimalDetect.class);
        return animalDetect;
    }

    /**
     * 植物识别接口   
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出植物识别结果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject plantDetect(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.PLANT_DETECT);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 植物识别接口
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出植物识别结果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return PlantDetect
     */
    public PlantDetect plantDetectPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = plantDetect(image, options);
        PlantDetect plantDetect = JSON.parseObject(object.toString(),PlantDetect.class);
        return plantDetect;
    }

    /**
     * 植物识别接口
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出植物识别结果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject plantDetect(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return plantDetect(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 植物识别接口
     * 该请求用于识别一张图片。即对于输入的一张图片（可正常解码，且长宽比适宜），输出植物识别结果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return PlantDetect
     */
    public PlantDetect plantDetectPro(String image, HashMap<String, String> options) {
        JSONObject object = plantDetect(image, options);
        PlantDetect plantDetect = JSON.parseObject(object.toString(),PlantDetect.class);
        return plantDetect;
    }

    /**
     * 图像主体检测接口   
     * 用户向服务请求检测图像中的主体位置。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   with_face 如果检测主体是人，主体区域是否带上人脸部分，0-不带人脸区域，其他-带人脸区域，裁剪类需求推荐带人脸，检索/识别类需求推荐不带人脸。默认取1，带人脸。
     * @return JSONObject
     */
    public JSONObject objectDetect(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);

        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.OBJECT_DETECT);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 图像主体检测接口
     * 用户向服务请求检测图像中的主体位置。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   with_face 如果检测主体是人，主体区域是否带上人脸部分，0-不带人脸区域，其他-带人脸区域，裁剪类需求推荐带人脸，检索/识别类需求推荐不带人脸。默认取1，带人脸。
     * @return ObjectDetect
     */
    public ObjectDetect objectDetectPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = objectDetect(image, options);
        ObjectDetect objectDetect = JSON.parseObject(object.toString(),ObjectDetect.class);
        return objectDetect;
    }

    /**
     * 图像主体检测接口
     * 用户向服务请求检测图像中的主体位置。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   with_face 如果检测主体是人，主体区域是否带上人脸部分，0-不带人脸区域，其他-带人脸区域，裁剪类需求推荐带人脸，检索/识别类需求推荐不带人脸。默认取1，带人脸。
     * @return JSONObject
     */
    public JSONObject objectDetect(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return objectDetect(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 图像主体检测接口
     * 用户向服务请求检测图像中的主体位置。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   with_face 如果检测主体是人，主体区域是否带上人脸部分，0-不带人脸区域，其他-带人脸区域，裁剪类需求推荐带人脸，检索/识别类需求推荐不带人脸。默认取1，带人脸。
     * @return ObjectDetect
     */
    public ObjectDetect objectDetectPro(String image, HashMap<String, String> options) {
        JSONObject object = objectDetect(image, options);
        ObjectDetect objectDetect = JSON.parseObject(object.toString(),ObjectDetect.class);
        return objectDetect;
    }

    /**
     * 地标识别接口   
     * 该请求用于识别地标，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的地标识别结果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject landmark(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.LANDMARK);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 地标识别接口
     * 该请求用于识别地标，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的地标识别结果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return LandmarkDetect
     */
    public LandmarkDetect landmarkPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = landmark(image, options);
        LandmarkDetect landmarkDetect = JSON.parseObject(object.toString(),LandmarkDetect.class);
        return landmarkDetect;
    }


    /**
     * 地标识别接口
     * 该请求用于识别地标，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的地标识别结果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject landmark(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return landmark(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 地标识别接口
     * 该请求用于识别地标，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的地标识别结果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return LandmarkDetect
     */
    public LandmarkDetect landmarkPro(String image, HashMap<String, String> options) {
        JSONObject object = landmark(image, options);
        LandmarkDetect landmarkDetect = JSON.parseObject(object.toString(),LandmarkDetect.class);
        return landmarkDetect;
    }

    /**
     * 花卉识别接口   
     * 检测用户上传的花卉图片，输出图片的花卉识别结果名称及对应的概率打分。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject flower(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.FLOWER);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 花卉识别接口
     * 检测用户上传的花卉图片，输出图片的花卉识别结果名称及对应的概率打分。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return FlowerDetect
     */
    public FlowerDetect flowerPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = flower(image, options);
        FlowerDetect flowerDetect = JSON.parseObject(object.toString(),FlowerDetect.class);
        return flowerDetect;
    }

    /**
     * 花卉识别接口
     * 检测用户上传的花卉图片，输出图片的花卉识别结果名称及对应的概率打分。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return JSONObject
     */
    public JSONObject flower(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return flower(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 花卉识别接口
     * 检测用户上传的花卉图片，输出图片的花卉识别结果名称及对应的概率打分。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，默认为5
     *   baike_num 返回百科信息的结果数，默认不返回
     * @return FlowerDetect
     */
    public FlowerDetect flowerPro(String image, HashMap<String, String> options) {
        JSONObject object = flower(image, options);
        FlowerDetect flowerDetect = JSON.parseObject(object.toString(),FlowerDetect.class);
        return flowerDetect;
    }

    /**
     * 食材识别接口   
     * 该请求用于识别果蔬类食材，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的果蔬食材结果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，如果为空或小于等于0默认为5；如果大于20默认20
     * @return JSONObject
     */
    public JSONObject ingredient(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.INGREDIENT);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 食材识别接口
     * 该请求用于识别果蔬类食材，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的果蔬食材结果。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，如果为空或小于等于0默认为5；如果大于20默认20
     * @return IngredientDetect
     */
    public IngredientDetect ingredientPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = ingredient(image, options);
        IngredientDetect ingredientDetect = JSON.parseObject(object.toString(),IngredientDetect.class);
        return ingredientDetect;
    }

    /**
     * 食材识别接口
     * 该请求用于识别果蔬类食材，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的果蔬食材结果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，如果为空或小于等于0默认为5；如果大于20默认20
     * @return JSONObject
     */
    public JSONObject ingredient(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return ingredient(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 食材识别接口
     * 该请求用于识别果蔬类食材，即对于输入的一张图片（可正常解码，且长宽比适宜），输出图片中的果蔬食材结果。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *   top_num 返回预测得分top结果数，如果为空或小于等于0默认为5；如果大于20默认20
     * @return IngredientDetect
     */
    public IngredientDetect ingredientPro(String image, HashMap<String, String> options) {
        JSONObject object = ingredient(image, options);
        IngredientDetect ingredientDetect = JSON.parseObject(object.toString(),IngredientDetect.class);
        return ingredientDetect;
    }

    /**
     * 红酒识别接口   
     * 该服务用于识别红酒标签，即对于输入的一张图片（可正常解码，长宽比适宜，且酒标清晰可见），输出图片中的红酒名称、国家、产区、酒庄、类型、糖分、葡萄品种、酒品描述等信息。可识别数十万中外常见红酒。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject redwine(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.REDWINE);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 红酒识别接口
     * 该服务用于识别红酒标签，即对于输入的一张图片（可正常解码，长宽比适宜，且酒标清晰可见），输出图片中的红酒名称、国家、产区、酒庄、类型、糖分、葡萄品种、酒品描述等信息。可识别数十万中外常见红酒。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return RedwineDetect
     */
    public RedwineDetect redwinePro(byte[] image, HashMap<String, String> options) {
        JSONObject object = redwine(image, options);
        RedwineDetect redwineDetect = JSON.parseObject(object.toString(),RedwineDetect.class);
        return redwineDetect;
    }

    /**
     * 红酒识别接口
     * 该服务用于识别红酒标签，即对于输入的一张图片（可正常解码，长宽比适宜，且酒标清晰可见），输出图片中的红酒名称、国家、产区、酒庄、类型、糖分、葡萄品种、酒品描述等信息。可识别数十万中外常见红酒。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject redwine(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return redwine(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 红酒识别接口
     * 该服务用于识别红酒标签，即对于输入的一张图片（可正常解码，长宽比适宜，且酒标清晰可见），输出图片中的红酒名称、国家、产区、酒庄、类型、糖分、葡萄品种、酒品描述等信息。可识别数十万中外常见红酒。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public RedwineDetect redwinePro(String image, HashMap<String, String> options) {
        JSONObject object = redwine(image, options);
        RedwineDetect redwineDetect = JSON.parseObject(object.toString(),RedwineDetect.class);
        return redwineDetect;
    }

    /**
     * 货币识别接口   
     * 识别图像中的货币类型，以纸币为主，正反面均可准确识别，接口返回货币的名称、代码、面值、年份信息；可识别各类近代常见货币，如美元、欧元、英镑、法郎、澳大利亚元、俄罗斯卢布、日元、韩元、泰铢、印尼卢比等。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject currency(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.CURRENCY);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 货币识别接口
     * 识别图像中的货币类型，以纸币为主，正反面均可准确识别，接口返回货币的名称、代码、面值、年份信息；可识别各类近代常见货币，如美元、欧元、英镑、法郎、澳大利亚元、俄罗斯卢布、日元、韩元、泰铢、印尼卢比等。
     *
     * @param image - 二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return CurrencyDetect
     */
    public CurrencyDetect currencyPro(byte[] image, HashMap<String, String> options) {
        JSONObject object = currency(image, options);
        CurrencyDetect currencyDetect = JSON.parseObject(object.toString(),CurrencyDetect.class);
        return currencyDetect;
    }


    /**
     * 货币识别接口
     * 识别图像中的货币类型，以纸币为主，正反面均可准确识别，接口返回货币的名称、代码、面值、年份信息；可识别各类近代常见货币，如美元、欧元、英镑、法郎、澳大利亚元、俄罗斯卢布、日元、韩元、泰铢、印尼卢比等。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return JSONObject
     */
    public JSONObject currency(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return currency(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 货币识别接口
     * 识别图像中的货币类型，以纸币为主，正反面均可准确识别，接口返回货币的名称、代码、面值、年份信息；可识别各类近代常见货币，如美元、欧元、英镑、法郎、澳大利亚元、俄罗斯卢布、日元、韩元、泰铢、印尼卢比等。
     *
     * @param image - 本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     * @return CurrencyDetect
     */
    public CurrencyDetect currencyPro(String image, HashMap<String, String> options) {
        JSONObject object = currency(image, options);
        CurrencyDetect currencyDetect = JSON.parseObject(object.toString(),CurrencyDetect.class);
        return currencyDetect;
    }

    /**
     * 自定义菜品-入库
     * 该请求用于入库自定义的单菜品图，实现上传多菜品图的精准识别，返回具体的菜名、位置、置信度信息 。
     *
     * @param image -  二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *                建议brief可传入图片在本地标记id、图片url、图片名称等
     * @return JSONObject
     */
    public JSONObject dishAdd(byte []image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);

        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        request.addBody("sub_lib", appId);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.DISH_REALTIME_ADD);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 自定义菜品-入库
     * 该请求用于入库自定义的单菜品图，实现上传多菜品图的精准识别，返回具体的菜名、位置、置信度信息 。
     *
     * @param image -  本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *                建议brief可传入图片在本地标记id、图片url、图片名称等
     * @return JSONObject
     */
    public JSONObject dishAdd(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return dishAdd(data, options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 自定义菜品-检索
     * 在已自建菜品库并入库的情况下，该接口实现单菜品/多菜品的识别
     *
     * @param image -  二进制图像数据
     * @return JSONObject
     */
    public JSONObject dishSearch(byte []image) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        request.addBody("sub_lib", appId);
        request.setUri(ImageClassifyConsts.DISH_REALTIME_SEARCH);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 自定义菜品-检索
     * 在已自建菜品库并入库的情况下，该接口实现单菜品/多菜品的识别
     *
     * @param image -  本地图片路径
     * @return JSONObject
     */
    public JSONObject dishSearch(String image) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return dishSearch(data);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 自定义菜品-删除
     * 该接口实现已入库菜品图片的删除操作。
     *
     * @param image -  二进制图像数据
     * @return JSONObject
     */
    public JSONObject dishDel(byte [] image) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        request.addBody("sub_lib", appId);
        request.setUri(ImageClassifyConsts.DISH_REALTIME_DELETE);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 自定义菜品-删除
     * 该接口实现已入库菜品图片的删除操作。
     *
     * @param cont_sign -  图片签名
     * @return JSONObject
     */
    public JSONObject dishDelByContSign(String cont_sign) {
        AipRequest request = new AipRequest();
        preOperation(request);
        request.addBody("cont_sign", cont_sign);
        request.addBody("sub_lib", appId);
        request.setUri(ImageClassifyConsts.DISH_REALTIME_DELETE);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 自定义菜品-删除
     * 该接口实现已入库菜品图片的删除操作。
     *
     * @param image -  本地图片路径
     * @return JSONObject
     */
    public JSONObject dishDel(String image) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return dishDel(data);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 车辆检测
     * 传入单帧图像，检测图片中所有机动车辆，返回每辆车的类型和坐标位置，可识别小汽车、卡车、巴士、摩托车、三轮车5大类车辆，并对每类车辆分别计数，同时可定位小汽车、卡车、巴士的车牌位置，支持指定矩形区域的车辆检测与数量统计。
     * 当前主要适用于普通监控场景，如道路、停车场等，无人机高空拍摄的图片，因车辆目标较小，识别效果可能欠佳，后续会扩展支持超高空拍摄场景，如有该场景的需求，请通过QQ群或提交工单，详细沟通测试情况。
     *
     * @param image -  二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * @return JSONObject
     */
    public JSONObject vehicleDetect(byte[] image, HashMap<String, String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.VEHICLE_DETECT);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 车辆检测
     * 传入单帧图像，检测图片中所有机动车辆，返回每辆车的类型和坐标位置，可识别小汽车、卡车、巴士、摩托车、三轮车5大类车辆，并对每类车辆分别计数，同时可定位小汽车、卡车、巴士的车牌位置，支持指定矩形区域的车辆检测与数量统计。
     * 当前主要适用于普通监控场景，如道路、停车场等，无人机高空拍摄的图片，因车辆目标较小，识别效果可能欠佳，后续会扩展支持超高空拍摄场景，如有该场景的需求，请通过QQ群或提交工单，详细沟通测试情况。
     *
     * @param image -  本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * @return JSONObject
     */
    public JSONObject vehicleDetect(String image, HashMap<String, String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return vehicleDetect(data,options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 车流统计（邀测）
     * 根据传入的连续视频图片序列，进行车辆检测和追踪，返回每个车辆的坐标位置、车辆类型（包括小汽车、卡车、巴士、摩托车、三轮车5大类）。在原图中指定区域，根据车辆轨迹判断驶入/驶出区域的行为，统计各类车辆的区域进出车流量，可返回含统计值和跟踪框的渲染图。
     *
     * @param image -  二进制图像数据
     * @param case_id 任务ID（通过case_id区分不同视频流，自拟，不同序列间不可重复）
     * @param case_init 每个case的初始化信号 true/false
     * @param area 只统计进出该区域的车辆。小于原图像素范围
     * @param show 是否返回结果图 true/false
     * @return JSONObject
     */
    public JSONObject trafficFlow(byte[] image, String case_id,boolean case_init,String area,boolean show) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        request.addBody("case_id", case_id);
        request.addBody("case_init", String.valueOf(case_init));
        request.addBody("area", area);
        request.addBody("show", String.valueOf(show));
        request.setUri(ImageClassifyConsts.TRAFFIC_FLOW);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 车流统计（邀测）
     * 根据传入的连续视频图片序列，进行车辆检测和追踪，返回每个车辆的坐标位置、车辆类型（包括小汽车、卡车、巴士、摩托车、三轮车5大类）。在原图中指定区域，根据车辆轨迹判断驶入/驶出区域的行为，统计各类车辆的区域进出车流量，可返回含统计值和跟踪框的渲染图。
     *
     * @param image -  本地图片路径
     * @param case_id 任务ID（通过case_id区分不同视频流，自拟，不同序列间不可重复）
     * @param case_init 每个case的初始化信号 true/false
     * @param area 只统计进出该区域的车辆。小于原图像素范围
     * @param show 是否返回结果图 true/false
     * @return JSONObject
     */
    public JSONObject trafficFlow(String image,String case_id,boolean case_init,String area,boolean show) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return trafficFlow(data,case_id,case_init,area,show);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 车流统计（邀测）
     * 根据传入的连续视频图片序列，进行车辆检测和追踪，返回每个车辆的坐标位置、车辆类型（包括小汽车、卡车、巴士、摩托车、三轮车5大类）。在原图中指定区域，根据车辆轨迹判断驶入/驶出区域的行为，统计各类车辆的区域进出车流量，可返回含统计值和跟踪框的渲染图。
     *
     * @param image -  二进制图像数据
     * @param case_id 任务ID（通过case_id区分不同视频流，自拟，不同序列间不可重复）
     * @param case_init 每个case的初始化信号 true/false
     * @param area 只统计进出该区域的车辆。小于原图像素范围
     * @return JSONObject
     */
    public JSONObject trafficFlow(byte[] image, String case_id,boolean case_init,String area) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("case_id", case_id);
        request.addBody("image", base64Content);
        request.addBody("case_init", String.valueOf(case_init));
        request.addBody("area", area);
        request.setUri(ImageClassifyConsts.TRAFFIC_FLOW);
        postOperation(request);
        return requestServer(request);
    }
    /**
     * 车流统计（邀测）
     * 根据传入的连续视频图片序列，进行车辆检测和追踪，返回每个车辆的坐标位置、车辆类型（包括小汽车、卡车、巴士、摩托车、三轮车5大类）。在原图中指定区域，根据车辆轨迹判断驶入/驶出区域的行为，统计各类车辆的区域进出车流量，可返回含统计值和跟踪框的渲染图。
     *
     * @param image -  本地图片路径
     * @param case_id 任务ID（通过case_id区分不同视频流，自拟，不同序列间不可重复）
     * @param case_init 每个case的初始化信号 true/false
     * @param area 只统计进出该区域的车辆。小于原图像素范围
     * @return JSONObject
     */
    public JSONObject trafficFlow(String image,String case_id,boolean case_init,String area) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return trafficFlow(data,case_id,case_init,area);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }
    /**
     * 车辆属性识别（邀测）
     * 传入单帧图像，检测图片中所有车辆，返回每辆车的类型和坐标位置，可识别小汽车、卡车、巴士、摩托车、三轮车、自行车6大类车辆，并针对小汽车识别11种外观属性，包括：是否有车窗雨眉、是否有车顶架、副驾驶是否有人、驾驶位是否系安全带、遮阳板是否放下、车辆朝向等。
     *
     * @param image -  二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *                是否选定某些属性输出对应的信息，可从12种输出属性中任选若干，用英文逗号分隔（例如vehicle_type,roof_rack,skylight）。默认输出全部属性
     * @return JSONObject
     */
    public JSONObject vehicleAttr(byte[] image, HashMap<String,String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.VEHICLE_ATTR);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 车辆属性识别（邀测）
     * 传入单帧图像，检测图片中所有车辆，返回每辆车的类型和坐标位置，可识别小汽车、卡车、巴士、摩托车、三轮车、自行车6大类车辆，并针对小汽车识别11种外观属性，包括：是否有车窗雨眉、是否有车顶架、副驾驶是否有人、驾驶位是否系安全带、遮阳板是否放下、车辆朝向等。
     *
     * @param image -  二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *                是否选定某些属性输出对应的信息，可从12种输出属性中任选若干，用英文逗号分隔（例如vehicle_type,roof_rack,skylight）。默认输出全部属性
     * @return VehicleAttrDetect
     */
    public VehicleAttrDetect vehicleAttrPro(byte[] image, HashMap<String,String> options) {
        JSONObject object = vehicleAttr(image, options);
        VehicleAttrDetect vehicleAttrDetect = JSON.parseObject(object.toString(),VehicleAttrDetect.class);
        return vehicleAttrDetect;
    }

    /**
     * 车辆属性识别（邀测）
     * 传入单帧图像，检测图片中所有车辆，返回每辆车的类型和坐标位置，可识别小汽车、卡车、巴士、摩托车、三轮车、自行车6大类车辆，并针对小汽车识别11种外观属性，包括：是否有车窗雨眉、是否有车顶架、副驾驶是否有人、驾驶位是否系安全带、遮阳板是否放下、车辆朝向等。
     *
     * @param image -  本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *                是否选定某些属性输出对应的信息，可从12种输出属性中任选若干，用英文逗号分隔（例如vehicle_type,roof_rack,skylight）。默认输出全部属性
     * @return JSONObject
     */
    public JSONObject vehicleAttr(String image, HashMap<String,String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return vehicleAttr(data,options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 车辆属性识别（邀测）
     * 传入单帧图像，检测图片中所有车辆，返回每辆车的类型和坐标位置，可识别小汽车、卡车、巴士、摩托车、三轮车、自行车6大类车辆，并针对小汽车识别11种外观属性，包括：是否有车窗雨眉、是否有车顶架、副驾驶是否有人、驾驶位是否系安全带、遮阳板是否放下、车辆朝向等。
     *
     * @param image -  本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表:
     *                是否选定某些属性输出对应的信息，可从12种输出属性中任选若干，用英文逗号分隔（例如vehicle_type,roof_rack,skylight）。默认输出全部属性
     * @return VehicleAttrDetect
     */
    public VehicleAttrDetect vehicleAttrPro(String image, HashMap<String,String> options) {
        JSONObject object = vehicleAttr(image, options);
        VehicleAttrDetect vehicleAttrDetect = JSON.parseObject(object.toString(),VehicleAttrDetect.class);
        return vehicleAttrDetect;
    }

    /**
     * 车辆外观损伤识别
     * 针对常见的小汽车车型，传入单帧图像，识别车辆外观受损部件及损伤类型，支持32种车辆部件、5大类外观损伤。同时可输出损伤的数值化结果（长宽、面积、部件占比），支持单图多种损伤的识别。
     *
     * @param image -  二进制图像数据
     * @return JSONObject
     */
    public JSONObject vehicleDamage(byte[] image) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        request.setUri(ImageClassifyConsts.VEHICLE_DAMAGE);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 车辆外观损伤识别
     * 针对常见的小汽车车型，传入单帧图像，识别车辆外观受损部件及损伤类型，支持32种车辆部件、5大类外观损伤。同时可输出损伤的数值化结果（长宽、面积、部件占比），支持单图多种损伤的识别。
     *
     * @param image -  二进制图像数据
     * @return VehicleDamageDetect
     */
    public VehicleDamageDetect vehicleDamagePro(byte[] image) {
        JSONObject object = vehicleDamage(image);
        VehicleDamageDetect vehicleDamageDetect = JSON.parseObject(object.toString(),VehicleDamageDetect.class);
        return vehicleDamageDetect;
    }

    /**
     * 车辆外观损伤识别
     * 针对常见的小汽车车型，传入单帧图像，识别车辆外观受损部件及损伤类型，支持32种车辆部件、5大类外观损伤。同时可输出损伤的数值化结果（长宽、面积、部件占比），支持单图多种损伤的识别。
     *
     * @param image -  本地图片路径
     * @return JSONObject
     */
    public JSONObject vehicleDamage(String image) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return vehicleDamage(data);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 车辆外观损伤识别
     * 针对常见的小汽车车型，传入单帧图像，识别车辆外观受损部件及损伤类型，支持32种车辆部件、5大类外观损伤。同时可输出损伤的数值化结果（长宽、面积、部件占比），支持单图多种损伤的识别。
     *
     * @param image -  本地图片路径
     * @return VehicleDamageDetect
     */
    public VehicleDamageDetect vehicleDamagePro(String image) {
        JSONObject object = vehicleDamage(image);
        VehicleDamageDetect vehicleDamageDetect = JSON.parseObject(object.toString(),VehicleDamageDetect.class);
        return vehicleDamageDetect;
    }

    /**
     * 车辆分割（邀测）
     * 传入单帧图像，检测图像中的车辆，以小汽车为主，识别车辆的轮廓范围，与背景进行分离，返回分割后的二值图、灰度图、前景抠图，支持多个车辆、车门打开、后备箱打开、机盖打开、正面、侧面、背面等各种拍摄场景。
     *
     * @param image -  二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表: type 参数值可以是可选值的组合，用逗号分隔；如果无此参数默认输出全部3类结果图
     *                type labelmap - 二值图像，需二次处理方能查看分割效果
     *                     scoremap - 车辆前景灰度图
     *                     foreground - 车辆前景抠图，透明背景
     * @return JSONObject
     */
    public JSONObject vehicleSeg(byte[] image,HashMap<String,String> options) {
        AipRequest request = new AipRequest();
        preOperation(request);
        String base64Content = Base64Util.encode(image);
        request.addBody("image", base64Content);
        if (options != null) {
            request.addBody(options);
        }
        request.setUri(ImageClassifyConsts.VEHICLE_SEG);
        postOperation(request);
        return requestServer(request);
    }

    /**
     * 车辆分割（邀测）
     * 传入单帧图像，检测图像中的车辆，以小汽车为主，识别车辆的轮廓范围，与背景进行分离，返回分割后的二值图、灰度图、前景抠图，支持多个车辆、车门打开、后备箱打开、机盖打开、正面、侧面、背面等各种拍摄场景。
     *
     * @param image -  二进制图像数据
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表: type 参数值可以是可选值的组合，用逗号分隔；如果无此参数默认输出全部3类结果图
     *                type labelmap - 二值图像，需二次处理方能查看分割效果
     *                     scoremap - 车辆前景灰度图
     *                     foreground - 车辆前景抠图，透明背景
     * @return VehicleSegDetect
     */
    public VehicleSegDetect vehicleSegPro(byte[] image,HashMap<String,String> options) {
        JSONObject object = vehicleSeg(image,options);
        VehicleSegDetect vehicleSegDetect = JSON.parseObject(object.toString(),VehicleSegDetect.class);
        return vehicleSegDetect;
    }

    /**
     * 车辆分割（邀测）
     * 传入单帧图像，检测图像中的车辆，以小汽车为主，识别车辆的轮廓范围，与背景进行分离，返回分割后的二值图、灰度图、前景抠图，支持多个车辆、车门打开、后备箱打开、机盖打开、正面、侧面、背面等各种拍摄场景。
     *
     * @param image -  本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表: type 参数值可以是可选值的组合，用逗号分隔；如果无此参数默认输出全部3类结果图
     *                type labelmap - 二值图像，需二次处理方能查看分割效果
     *                     scoremap - 车辆前景灰度图
     *                     foreground - 车辆前景抠图，透明背景
     * @return JSONObject
     */
    public JSONObject vehicleSeg(String image,HashMap<String,String> options) {
        try {
            byte[] data = Util.readFileByBytes(image);
            return vehicleSeg(data,options);
        } catch (IOException e) {
            e.printStackTrace();
            return AipError.IMAGE_READ_ERROR.toJsonResult();
        }
    }

    /**
     * 车辆分割（邀测）
     * 传入单帧图像，检测图像中的车辆，以小汽车为主，识别车辆的轮廓范围，与背景进行分离，返回分割后的二值图、灰度图、前景抠图，支持多个车辆、车门打开、后备箱打开、机盖打开、正面、侧面、背面等各种拍摄场景。
     *
     * @param image -  本地图片路径
     * @param options - 可选参数对象，key: value都为string类型
     * options - options列表: type 参数值可以是可选值的组合，用逗号分隔；如果无此参数默认输出全部3类结果图
     *                type labelmap - 二值图像，需二次处理方能查看分割效果
     *                     scoremap - 车辆前景灰度图
     *                     foreground - 车辆前景抠图，透明背景
     * @return VehicleSegDetect
     */
    public VehicleSegDetect vehicleSegPro(String image,HashMap<String,String> options) {
        JSONObject object = vehicleSeg(image,options);
        VehicleSegDetect vehicleSegDetect = JSON.parseObject(object.toString(),VehicleSegDetect.class);
        return vehicleSegDetect;
    }
}